home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / lisp / wgdb-42.lha / wgdb-4.2 / gdb / remote-mm.c < prev    next >
C/C++ Source or Header  |  1992-09-11  |  51KB  |  1,707 lines
  1. /* Remote debugging interface for Am290*0 running MiniMON monitor, for GDB.
  2.    Copyright (C) 1990, 1991 Free Software Foundation, Inc.
  3.    Originally written by Daniel Mann at AMD.
  4.  
  5. This file is part of GDB.
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program; if not, write to the Free Software
  19. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. /* This is like remote.c but ecpects MiniMON to be running on the Am29000 
  22.    target hardware.
  23.  - David Wood (wood@lab.ultra.nyu.edu) at New York University adapted this
  24.     file to gdb 3.95.  I was unable to get this working on sun3os4
  25.     with termio, only with sgtty.  Because we are only attempting to
  26.     use this module to debug our kernel, which is already loaded when
  27.     gdb is started up, I did not code up the file downloading facilities.  
  28.     As a result this module has only the stubs to download files. 
  29.     You should get tagged at compile time if you need to make any 
  30.     changes/additions.  */
  31.  
  32. #include <stdio.h>
  33. #include "defs.h"
  34. #include "inferior.h"
  35. #include "wait.h"
  36. #include "value.h"
  37. #include <ctype.h>
  38. #include <fcntl.h>
  39. #include <signal.h>
  40. #include <errno.h>
  41. #include <string.h>
  42. #include "terminal.h"
  43. #include "minimon.h"
  44. #include "target.h"
  45.  
  46. /* Offset of member MEMBER in a struct of type TYPE.  */
  47. #define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)
  48.  
  49. /* #define DEBUG 1        /* */
  50. #ifdef DEBUG
  51. # define DENTER(NAME)    (printf("Entering %s\n",NAME), fflush(stdout)) 
  52. # define DEXIT(NAME)    (printf("Exiting  %s\n",NAME), fflush(stdout))
  53. #else
  54. # define DENTER(NAME)    
  55. # define DEXIT(NAME)    
  56. #endif 
  57.  
  58. #define DRAIN_INPUT()    (msg_recv_serial((union msg_t*)0))
  59.  
  60. extern int stop_soon_quietly;           /* for wait_for_inferior */
  61.  
  62. extern struct value *call_function_by_hand();
  63.  
  64. static void mm_resume();
  65. static void mm_fetch_registers ();
  66. static int fetch_register ();
  67. static int mm_store_registers ();
  68. static int store_register ();
  69. static int regnum_to_srnum();
  70. static void  mm_close ();
  71. static char* msg_str();
  72. static char* error_msg_str();
  73. static int expect_msg();
  74. static void init_target_mm();
  75. static int mm_memory_space();
  76.  
  77. /*
  78.  * Processor types. 
  79.  */
  80. #define TYPE_UNKNOWN    0
  81. #define TYPE_A29000     1
  82. #define TYPE_A29030     2
  83. #define TYPE_A29050     3
  84. static  char *processor_name[] = { "Unknown", "A29000", "A29030", "A29050" };
  85. static  int processor_type=TYPE_UNKNOWN;
  86. #define FREEZE_MODE     (read_register(CPS_REGNUM) && 0x400)
  87. #define USE_SHADOW_PC    ((processor_type == TYPE_A29050) && FREEZE_MODE) 
  88.  
  89. #define LLOG_FILE "minimon.log"
  90. #if defined (LOG_FILE)
  91. FILE *log_file;
  92. #endif
  93.  
  94. /*  
  95.  * Size of message buffers.  I couldn't get memory reads to work when
  96.  * the byte_count was larger than 512 (it may be a baud rate problem).
  97.  */
  98. #define BUFER_SIZE  512        
  99. /* 
  100.  * Size of data area in message buffer on the TARGET (remote system).
  101.  */
  102. #define MAXDATA_T  (target_config.max_msg_size - \
  103.             offsetof(struct write_r_msg_t,data[0]))
  104. /*         
  105.  * Size of data area in message buffer on the HOST (gdb). 
  106.  */
  107. #define MAXDATA_H  (BUFER_SIZE - offsetof(struct write_r_msg_t,data[0]))
  108. /* 
  109.  * Defined as the minimum size of data areas of the two message buffers 
  110.  */
  111. #define MAXDATA       (MAXDATA_H < MAXDATA_T ? MAXDATA_H : MAXDATA_T)
  112.  
  113. static char out_buf[BUFER_SIZE];
  114. static char  in_buf[BUFER_SIZE];
  115.  
  116. int msg_recv_serial();
  117. int msg_send_serial();
  118.  
  119. #define MAX_RETRIES 5000
  120. extern struct target_ops mm_ops;             /* Forward declaration */
  121. struct config_msg_t  target_config;    /* HIF needs this */
  122. union msg_t  *out_msg_buf = (union msg_t*)out_buf;
  123. union msg_t  *in_msg_buf  = (union msg_t*)in_buf;
  124.  
  125. static int timeout = 5;
  126.  
  127. /* Descriptor for I/O to remote machine.  Initialize it to -1 so that
  128.    mm_open knows that we don't have a file open when the program
  129.    starts.  */
  130. int mm_desc = -1;
  131.  
  132. /* stream which is fdopen'd from mm_desc.  Only valid when
  133.    mm_desc != -1.  */
  134. FILE *mm_stream;
  135.  
  136. /* Called when SIGALRM signal sent due to alarm() timeout.  */
  137. #ifndef HAVE_TERMIO
  138.  
  139. #ifndef __STDC__
  140. # ifndef volatile
  141. #  define volatile /**/
  142. # endif
  143. #endif
  144. volatile int n_alarms;
  145.  
  146. static void
  147. mm_timer ()
  148. {
  149. #if 0
  150.   if (kiodebug)
  151.     printf ("mm_timer called\n");
  152. #endif
  153.   n_alarms++;
  154. }
  155. #endif    /* HAVE_TERMIO */
  156.  
  157. /* malloc'd name of the program on the remote system.  */
  158. static char *prog_name = NULL;
  159.  
  160.  
  161. /* Number of SIGTRAPs we need to simulate.  That is, the next
  162.    NEED_ARTIFICIAL_TRAP calls to mm_wait should just return
  163.    SIGTRAP without actually waiting for anything.  */
  164.  
  165. /**************************************************** REMOTE_CREATE_INFERIOR */
  166. /* This is called not only when we first attach, but also when the
  167.    user types "run" after having attached.  */
  168. static void
  169. mm_create_inferior (execfile, args, env)
  170.      char *execfile;
  171.      char *args;
  172.      char **env;
  173. {
  174. #define MAX_TOKENS 25
  175. #define BUFFER_SIZE 256
  176.    int    token_count;
  177.    int    result;
  178.    char    *token[MAX_TOKENS];
  179.    char    cmd_line[BUFFER_SIZE];
  180.  
  181.   DENTER("mm_create_inferior()");
  182.  
  183.   if (args && *args)
  184.     error ("Can't pass arguments to remote mm process (yet).");
  185.  
  186.   if (execfile == 0 /* || exec_bfd == 0 */ )
  187.     error ("No exec file specified");
  188.  
  189.   if (!mm_stream) {
  190.         printf("Minimon not open yet.\n");
  191.     return;
  192.   }
  193.  
  194.   /* On ultra3 (NYU) we assume the kernel is already running so there is
  195.      no file to download.
  196.      FIXME: Fixed required here -> load your program, possibly with mm_load().
  197.      */
  198.   printf_filtered ("\n\
  199. Assuming you are at NYU debuging a kernel, i.e., no need to download.\n\n");
  200.  
  201.   /* We will get a task spawn event immediately.  */
  202. #ifdef NOTDEF        /* start_remote() now does a wait without a resume 
  203.                so don't use it*/ 
  204.   start_remote ();
  205. #else
  206.   init_wait_for_inferior ();
  207.   clear_proceed_status ();
  208.   stop_soon_quietly = 1;
  209.   proceed(-1,-1,0);
  210.   normal_stop ();
  211. #endif
  212.   DEXIT("mm_create_inferior()");
  213. }
  214. /**************************************************** REMOTE_MOURN_INFERIOR */
  215. static void
  216. mm_mourn()
  217. {
  218.   DENTER("mm_mourn()");
  219.         pop_target ();                /* Pop back to no-child state */
  220.         generic_mourn_inferior ();
  221.   DEXIT("mm_mourn()");
  222. }
  223.  
  224. /********************************************************************** damn_b
  225. */
  226. /* Translate baud rates from integers to damn B_codes.  Unix should
  227.    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
  228.  
  229. #ifndef B19200
  230. #define B19200 EXTA
  231. #endif
  232. #ifndef B38400
  233. #define B38400 EXTB
  234. #endif
  235.  
  236. static struct {int rate, damn_b;} baudtab[] = {
  237.     {0, B0},
  238.     {50, B50},
  239.     {75, B75},
  240.     {110, B110},
  241.     {134, B134},
  242.     {150, B150},
  243.     {200, B200},
  244.     {300, B300},
  245.     {600, B600},
  246.     {1200, B1200},
  247.     {1800, B1800},
  248.     {2400, B2400},
  249.     {4800, B4800},
  250.     {9600, B9600},
  251.     {19200, B19200},
  252.     {38400, B38400},
  253.     {-1, -1},
  254. };
  255.  
  256. static int damn_b (rate)
  257.      int rate;
  258. {
  259.   int i;
  260.  
  261.   for (i = 0; baudtab[i].rate != -1; i++)
  262.     if (rate == baudtab[i].rate) return baudtab[i].damn_b;
  263.   return B38400;    /* Random */
  264. }
  265.  
  266.  
  267. /***************************************************************** REMOTE_OPEN
  268. ** Open a connection to remote minimon.
  269.    NAME is the filename used for communication, then a space,
  270.    then the baud rate.
  271.    'target adapt /dev/ttya 9600 [prognam]' for example.
  272.  */
  273.  
  274. static char *dev_name;
  275. int baudrate = 9600;
  276. static void
  277. mm_open (name, from_tty)
  278.      char *name;
  279.      int from_tty;
  280. {
  281.   TERMINAL sg;
  282.   unsigned int prl;
  283.   char *p;
  284.  
  285.   DENTER("mm_open()");
  286.  
  287.   /* Find the first whitespace character, it separates dev_name from
  288.      prog_name.  */
  289.   for (p = name;
  290.        p && *p && !isspace (*p); p++)
  291.     ;
  292.   if (p == 0 || *p == '\0')
  293. erroid:
  294.     error ("Usage : <command> <serial-device> <baud-rate> [progname]");
  295.   dev_name = (char*)malloc (p - name + 1);
  296.   strncpy (dev_name, name, p - name);
  297.   dev_name[p - name] = '\0';
  298.  
  299.   /* Skip over the whitespace after dev_name */
  300.   for (; isspace (*p); p++)
  301.     /*EMPTY*/;
  302.   
  303.   if (1 != sscanf (p, "%d ", &baudrate))
  304.     goto erroid;
  305.  
  306.   /* Skip the number and then the spaces */
  307.   for (; isdigit (*p); p++)
  308.     /*EMPTY*/;
  309.   for (; isspace (*p); p++)
  310.     /*EMPTY*/;
  311.   
  312.   if (prog_name != NULL)
  313.     free (prog_name);
  314.   prog_name = savestring (p, strlen (p));
  315.  
  316.  
  317.   if (mm_desc >= 0)
  318.     close (mm_desc);
  319.  
  320.   mm_desc = open (dev_name, O_RDWR);
  321.   if (mm_desc < 0)
  322.     perror_with_name (dev_name);
  323.   ioctl (mm_desc, TIOCGETP, &sg);
  324. #ifdef HAVE_TERMIO
  325.   sg.c_cc[VMIN] = 0;        /* read with timeout.  */
  326.   sg.c_cc[VTIME] = timeout * 10;
  327.   sg.c_lflag &= ~(ICANON | ECHO);
  328.   sg.c_cflag = (sg.c_cflag & ~CBAUD) | damn_b (baudrate);
  329. #else
  330.   sg.sg_ispeed = damn_b (baudrate);
  331.   sg.sg_ospeed = damn_b (baudrate);
  332.   sg.sg_flags |= RAW;
  333.   sg.sg_flags |= ANYP;
  334.   sg.sg_flags &= ~ECHO;
  335. #endif
  336.  
  337.  
  338.   ioctl (mm_desc, TIOCSETP, &sg);
  339.   mm_stream = fdopen (mm_desc, "r+");
  340.  
  341.   push_target (&mm_ops);
  342.  
  343. #ifndef HAVE_TERMIO
  344. #ifndef NO_SIGINTERRUPT
  345.   /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
  346.      the read.  */
  347.   if (siginterrupt (SIGALRM, 1) != 0)
  348.     perror ("mm_open: error in siginterrupt");
  349. #endif
  350.  
  351.   /* Set up read timeout timer.  */
  352.   if ((void (*)) signal (SIGALRM, mm_timer) == (void (*)) -1)
  353.     perror ("mm_open: error in signal");
  354. #endif
  355.  
  356. #if defined (LOG_FILE)
  357.   log_file = fopen (LOG_FILE, "w");
  358.   if (log_file == NULL)
  359.     perror_with_name (LOG_FILE);
  360. #endif
  361.    /*
  362.    ** Initialize target configuration structure (global)
  363.    */
  364.    DRAIN_INPUT();
  365.    out_msg_buf->config_req_msg.code = CONFIG_REQ;
  366.    out_msg_buf->config_req_msg.length = 4*0;
  367.    msg_send_serial(out_msg_buf); /* send config request message */
  368.  
  369.    expect_msg(CONFIG,in_msg_buf,1);
  370.  
  371.   /* Determine the processor revision level */
  372.   /* FIXME: this code is the same as in remote-adapt.c */
  373.   prl = (unsigned int)read_register(CFG_REGNUM) >> 24;
  374.   if (prl == 0x03) {
  375.         processor_type = TYPE_A29000;
  376.   } else if ((prl&0xf0) == 0x40) {      /* 29030 = 0x4* */
  377.         processor_type = TYPE_A29030;
  378.         fprintf_filtered(stderr,"WARNING: debugging of A29030 not tested.\n");
  379.   } else if ((prl&0xf0) == 0x20) {      /* 29050 = 0x2* */
  380.         processor_type = TYPE_A29050;
  381.         fprintf_filtered(stderr,"WARNING: debugging of A29050 not tested.\n");
  382.   } else {
  383.         processor_type = TYPE_UNKNOWN;
  384.         fprintf_filtered(stderr,"WARNING: processor type unknown.\n");
  385.   }
  386.  
  387.   /* Print out some stuff, letting the user now what's going on */
  388.   printf_filtered("Remote debugging on an %s connect to MiniMon via %s.\n",
  389.                 processor_name[processor_type],dev_name);
  390.     /* FIXME: can this restriction be removed? */
  391.   printf_filtered("Remote debugging using virtual addresses works only\n");
  392.   printf_filtered("\twhen virtual addresses map 1:1 to physical addresses.\n")
  393. ;
  394.   if (processor_type != TYPE_A29050) {
  395.         fprintf_filtered(stderr,
  396.         "Freeze-mode debugging not available, and can only be done on an A29050.\n");
  397.   }
  398.  
  399.    target_config.code = CONFIG;
  400.    target_config.length = 0;
  401.    target_config.processor_id = in_msg_buf->config_msg.processor_id;
  402.    target_config.version = in_msg_buf->config_msg.version;
  403.    target_config.I_mem_start = in_msg_buf->config_msg.I_mem_start;
  404.    target_config.I_mem_size = in_msg_buf->config_msg.I_mem_size;
  405.    target_config.D_mem_start = in_msg_buf->config_msg.D_mem_start;
  406.    target_config.D_mem_size = in_msg_buf->config_msg.D_mem_size;
  407.    target_config.ROM_start = in_msg_buf->config_msg.ROM_start;
  408.    target_config.ROM_size =  in_msg_buf->config_msg.ROM_size;
  409.    target_config.max_msg_size = in_msg_buf->config_msg.max_msg_size;
  410.    target_config.max_bkpts = in_msg_buf->config_msg.max_bkpts;
  411.    target_config.coprocessor = in_msg_buf->config_msg.coprocessor;
  412.    target_config.reserved = in_msg_buf->config_msg.reserved;
  413.    if (from_tty) {
  414.        printf("Connected to MiniMON :\n");
  415.     printf("    Debugcore version            %d.%d\n",
  416.         0x0f & (target_config.version >> 4),
  417.         0x0f & (target_config.version ) );
  418.     printf("    Configuration version        %d.%d\n",
  419.         0x0f & (target_config.version >> 12),
  420.         0x0f & (target_config.version >>  8) );
  421.     printf("    Message system version       %d.%d\n",
  422.         0x0f & (target_config.version >> 20),
  423.         0x0f & (target_config.version >> 16) );
  424.     printf("    Communication driver version %d.%d\n",
  425.         0x0f & (target_config.version >> 28),
  426.         0x0f & (target_config.version >> 24) );
  427.    }
  428.  
  429.   /* Leave the target running... 
  430.    * The above message stopped the target in the dbg core (MiniMon),  
  431.    * so restart the target out of MiniMon, 
  432.    */
  433.   out_msg_buf->go_msg.code = GO;
  434.   out_msg_buf->go_msg.length = 0;
  435.   msg_send_serial(out_msg_buf);
  436.   /* No message to expect after a GO */
  437.  
  438.   DEXIT("mm_open()");
  439. }
  440.  
  441. /**************************************************************** REMOTE_CLOSE
  442. ** Close the open connection to the minimon debugger.
  443.    Use this when you want to detach and do something else
  444.    with your gdb.  */
  445. static void
  446. mm_close (quitting)    /*FIXME: how is quitting used */
  447.      int quitting;
  448. {
  449.   DENTER("mm_close()");
  450.  
  451.   if (mm_desc < 0)
  452.     error ("Can't close remote connection: not debugging remotely.");
  453.  
  454.   /* We should never get here if there isn't something valid in
  455.      mm_desc and mm_stream.  
  456.  
  457.      Due to a bug in Unix, fclose closes not only the stdio stream,
  458.      but also the file descriptor.  So we don't actually close
  459.      mm_desc.  */
  460.   DRAIN_INPUT();
  461.   fclose (mm_stream);    
  462.   /* close (mm_desc); */
  463.  
  464.   /* Do not try to close mm_desc again, later in the program.  */
  465.   mm_stream = NULL;
  466.   mm_desc = -1;
  467.  
  468. #if defined (LOG_FILE)
  469.   if (ferror (log_file))
  470.     printf ("Error writing log file.\n");
  471.   if (fclose (log_file) != 0)
  472.     printf ("Error closing log file.\n");
  473. #endif
  474.  
  475.   printf ("Ending remote debugging\n");
  476.  
  477.   DEXIT("mm_close()");
  478.  
  479. } 
  480.  
  481. /************************************************************* REMOTE_ATACH */
  482. /* Attach to a program that is already loaded and running 
  483.  * Upon exiting the process's execution is stopped.
  484.  */
  485. static void
  486. mm_attach (args, from_tty)
  487.      char *args;
  488.      int from_tty;
  489. {
  490.  
  491.   DENTER("mm_attach()");
  492.  
  493.   if (!mm_stream)
  494.       printf ("MiniMon not opened yet, use the 'target minimon' command.\n");
  495.     
  496.   dont_repeat();
  497.  
  498.   if (from_tty)
  499.       printf ("Attaching to remote program %s...\n", prog_name);
  500.  
  501.  
  502.   /* Make sure the target is currently running, it is supposed to be. */
  503.   /* FIXME: is it ok to send MiniMon a BREAK if it is already stopped in 
  504.    *     the dbg core.  If so, we don't need to send this GO.
  505.    */
  506.   out_msg_buf->go_msg.code = GO;
  507.   out_msg_buf->go_msg.length = 0;
  508.   msg_send_serial(out_msg_buf);
  509.   sleep(2);    /* At the worst it will stop, receive a message, continue */
  510.  
  511.   /* Send the mm a break. */ 
  512.   out_msg_buf->break_msg.code = BREAK;
  513.   out_msg_buf->break_msg.length = 0;
  514.   msg_send_serial(out_msg_buf);
  515.  
  516.   mark_breakpoints_out ();
  517.   init_wait_for_inferior ();
  518.   clear_proceed_status ();
  519.   stop_soon_quietly = 1;
  520.   wait_for_inferior ();
  521.   stop_soon_quietly = 0;
  522.   normal_stop ();
  523.  
  524.   DEXIT("mm_attach()");
  525. }
  526. /********************************************************** REMOTE_DETACH */
  527. /* Terminate the open connection to the remote debugger.
  528.    Use this when you want to detach and do something else
  529.    with your gdb.  Leave remote process running (with no breakpoints set). */
  530. static void
  531. mm_detach (args,from_tty)
  532.      char *args;
  533.      int from_tty;
  534. {
  535.   DENTER("mm_dettach()");
  536.   remove_breakpoints();        /* Just in case there were any left in */
  537.   out_msg_buf->go_msg.code = GO;
  538.   out_msg_buf->go_msg.length = 0;
  539.   msg_send_serial(out_msg_buf);
  540.   pop_target();             /* calls mm_close to do the real work */
  541.   DEXIT("mm_dettach()");
  542. }
  543.  
  544.  
  545. /*************************************************************** REMOTE_RESUME
  546. ** Tell the remote machine to resume.  */
  547.  
  548. static void
  549. mm_resume (step, sig)
  550.      int step, sig;
  551. {
  552.   DENTER("mm_resume()");
  553.  
  554.   if (sig)
  555.     error ("Can't send signals to a remote MiniMon system.");
  556.  
  557.   if (step) {
  558.       out_msg_buf->step_msg.code= STEP;
  559.       out_msg_buf->step_msg.length = 1*4;
  560.       out_msg_buf->step_msg.count = 1;        /* step 1 instruction */
  561.       msg_send_serial(out_msg_buf);
  562.   } else {
  563.       out_msg_buf->go_msg.code= GO;
  564.       out_msg_buf->go_msg.length = 0;
  565.       msg_send_serial(out_msg_buf);
  566.   }
  567.  
  568.   DEXIT("mm_resume()");
  569. }
  570.  
  571. /***************************************************************** REMOTE_WAIT
  572. ** Wait until the remote machine stops, then return,
  573.    storing status in STATUS just as `wait' would.  */
  574.  
  575. static int
  576. mm_wait (status)
  577.      WAITTYPE *status;
  578. {
  579.   int i, result;
  580.   int old_timeout = timeout;
  581.   int old_immediate_quit = immediate_quit;
  582.  
  583.   DENTER("mm_wait()");
  584.   WSETEXIT ((*status), 0);
  585.  
  586.  
  587. /* wait for message to arrive. It should be:
  588.     - A HIF service request.
  589.     - A HIF exit service request.
  590.     - A CHANNEL0_ACK.
  591.     - A CHANNEL1 request.
  592.     - a debugcore HALT message.
  593.   HIF services must be responded too, and while-looping continued.
  594.   If the target stops executing, mm_wait() should return.
  595. */
  596.   timeout = 0;    /* Wait indefinetly for a message */
  597.   immediate_quit = 1;   /* Helps ability to QUIT */
  598.   while(1)
  599.   {
  600.     while(msg_recv_serial(in_msg_buf)) {
  601.         QUIT;    /* Let user quit if they want */
  602.     }
  603.     switch (in_msg_buf->halt_msg.code)
  604.     {
  605.     case HIF_CALL:
  606.     i = in_msg_buf->hif_call_rtn_msg.service_number;
  607.     result=service_HIF(in_msg_buf);
  608.        if(i == 1) /* EXIT */
  609.         goto exit;
  610.     if(result)
  611.         printf("Warning: failure during HIF service %d\n", i);
  612.     break;
  613.     case CHANNEL0_ACK:
  614.     service_HIF(in_msg_buf);
  615.     break;
  616.     case CHANNEL1:
  617.         i=in_msg_buf->channel1_msg.length;
  618.         in_msg_buf->channel1_msg.data[i] = '\0';
  619.         printf("%s", in_msg_buf->channel1_msg.data);
  620.     fflush(stdout);
  621.         /* Send CHANNEL1_ACK message */
  622.         out_msg_buf->channel1_ack_msg.code = CHANNEL1_ACK;
  623.         out_msg_buf->channel1_ack_msg.length = 0;
  624.         result = msg_send_serial(out_msg_buf);
  625.     break;
  626.     case HALT:
  627.     goto halted;
  628.     default:
  629.     goto halted;
  630.     }
  631.   }
  632. halted:
  633.   /* FIXME, these printfs should not be here.  This is a source level 
  634.      debugger, guys!  */
  635.   if (in_msg_buf->halt_msg.trap_number== 0)
  636.   { printf("Am290*0 received vector number %d (break point)\n",
  637.     in_msg_buf->halt_msg.trap_number);
  638.     WSETSTOP ((*status), SIGTRAP);
  639.   }
  640.   else if (in_msg_buf->halt_msg.trap_number== 1)
  641.   { printf("Am290*0 received vector number %d\n",
  642.     in_msg_buf->halt_msg.trap_number);
  643.     WSETSTOP ((*status), SIGBUS);
  644.   }
  645.   else if (in_msg_buf->halt_msg.trap_number== 3
  646.         || in_msg_buf->halt_msg.trap_number== 4)
  647.   { printf("Am290*0 received vector number %d\n",
  648.     in_msg_buf->halt_msg.trap_number);
  649.     WSETSTOP ((*status), SIGFPE);
  650.   }
  651.   else if (in_msg_buf->halt_msg.trap_number== 5)
  652.   { printf("Am290*0 received vector number %d\n",
  653.     in_msg_buf->halt_msg.trap_number);
  654.     WSETSTOP ((*status), SIGILL);
  655.   }
  656.   else if (in_msg_buf->halt_msg.trap_number >= 6
  657.         && in_msg_buf->halt_msg.trap_number <= 11)
  658.   { printf("Am290*0 received vector number %d\n",
  659.     in_msg_buf->halt_msg.trap_number);
  660.     WSETSTOP ((*status), SIGSEGV);
  661.   }
  662.   else if (in_msg_buf->halt_msg.trap_number== 12
  663.         || in_msg_buf->halt_msg.trap_number== 13)
  664.   { printf("Am290*0 received vector number %d\n",
  665.     in_msg_buf->halt_msg.trap_number);
  666.     WSETSTOP ((*status), SIGILL);
  667.   }
  668.   else if (in_msg_buf->halt_msg.trap_number== 14)
  669.   { printf("Am290*0 received vector number %d\n",
  670.     in_msg_buf->halt_msg.trap_number);
  671.     WSETSTOP ((*status), SIGALRM);
  672.   }
  673.   else if (in_msg_buf->halt_msg.trap_number== 15)
  674.     WSETSTOP ((*status), SIGTRAP);
  675.   else if (in_msg_buf->halt_msg.trap_number >= 16
  676.         && in_msg_buf->halt_msg.trap_number <= 21)
  677.   { printf("Am290*0 received vector number %d\n",
  678.     in_msg_buf->halt_msg.trap_number);
  679.     WSETSTOP ((*status), SIGINT);
  680.   }
  681.   else if (in_msg_buf->halt_msg.trap_number== 22)
  682.   { printf("Am290*0 received vector number %d\n",
  683.     in_msg_buf->halt_msg.trap_number);
  684.     WSETSTOP ((*status), SIGILL);
  685.   } /* BREAK message was sent */
  686.   else if (in_msg_buf->halt_msg.trap_number== 75)
  687.     WSETSTOP ((*status), SIGTRAP);
  688.   else
  689. exit:
  690.     WSETEXIT ((*status), 0);
  691.  
  692.   timeout = old_timeout;    /* Restore original timeout value */
  693.   immediate_quit = old_immediate_quit;
  694.   DEXIT("mm_wait()");
  695.   return 0;
  696. }
  697.  
  698. /******************************************************* REMOTE_FETCH_REGISTERS
  699.  * Read a remote register 'regno'. 
  700.  * If regno==-1 then read all the registers.
  701.  */
  702. static void 
  703. mm_fetch_registers (regno)
  704. int    regno;
  705. {
  706.   INT32 *data_p;
  707.  
  708.   if (regno >= 0)  {
  709.     fetch_register(regno);
  710.     return;
  711.   }
  712.  
  713.   DENTER("mm_fetch_registers()");
  714.  
  715. /* Gr1/rsp */
  716.   out_msg_buf->read_req_msg.byte_count = 4*1;
  717.   out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
  718.   out_msg_buf->read_req_msg.address = 1;
  719.   msg_send_serial(out_msg_buf);
  720.   expect_msg(READ_ACK,in_msg_buf,1);
  721.   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
  722.   supply_register (GR1_REGNUM , data_p);
  723.  
  724. #if defined(GR64_REGNUM)    /* Read gr64-127 */
  725. /* Global Registers gr64-gr95 */ 
  726.   out_msg_buf->read_req_msg.code= READ_REQ;
  727.   out_msg_buf->read_req_msg.length = 4*3;
  728.   out_msg_buf->read_req_msg.byte_count = 4*32;
  729.   out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
  730.   out_msg_buf->read_req_msg.address = 64;
  731.   msg_send_serial(out_msg_buf);
  732.   expect_msg(READ_ACK,in_msg_buf,1);
  733.   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
  734.  
  735.   for (regno=GR64_REGNUM; regno<GR64_REGNUM+32; regno++) {
  736.       supply_register (regno, data_p++);
  737.   }
  738. #endif    /*  GR64_REGNUM */
  739.  
  740. /* Global Registers gr96-gr127 */ 
  741.   out_msg_buf->read_req_msg.code= READ_REQ;
  742.   out_msg_buf->read_req_msg.length = 4*3;
  743.   out_msg_buf->read_req_msg.byte_count = 4 * 32;
  744.   out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
  745.   out_msg_buf->read_req_msg.address = 96;
  746.   msg_send_serial(out_msg_buf);
  747.   expect_msg(READ_ACK,in_msg_buf,1);
  748.   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
  749.  
  750.   for (regno=GR96_REGNUM; regno<GR96_REGNUM+32; regno++) {
  751.       supply_register (regno, data_p++);
  752.   }
  753.  
  754. /* Local Registers */ 
  755.   out_msg_buf->read_req_msg.byte_count = 4 * (128);
  756.   out_msg_buf->read_req_msg.memory_space = LOCAL_REG;
  757.   out_msg_buf->read_req_msg.address = 0;
  758.   msg_send_serial(out_msg_buf);
  759.   expect_msg(READ_ACK,in_msg_buf,1);
  760.   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
  761.  
  762.   for (regno=LR0_REGNUM; regno<LR0_REGNUM+128; regno++) {
  763.       supply_register (regno, data_p++);
  764.   }
  765.  
  766. /* Protected Special Registers */ 
  767.   out_msg_buf->read_req_msg.byte_count = 4*15;
  768.   out_msg_buf->read_req_msg.memory_space = SPECIAL_REG;
  769.   out_msg_buf->read_req_msg.address = 0;
  770.   msg_send_serial( out_msg_buf);
  771.   expect_msg(READ_ACK,in_msg_buf,1);
  772.   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
  773.  
  774.   for (regno=0; regno<=14; regno++) {
  775.       supply_register (SR_REGNUM(regno), data_p++);
  776.   }
  777.   if (USE_SHADOW_PC) {    /* Let regno_to_srnum() handle the register number */
  778.     fetch_register(NPC_REGNUM);
  779.     fetch_register(PC_REGNUM);
  780.     fetch_register(PC2_REGNUM);
  781.   }
  782.  
  783. /* Unprotected Special Registers */ 
  784.   out_msg_buf->read_req_msg.byte_count = 4*8;
  785.   out_msg_buf->read_req_msg.memory_space = SPECIAL_REG;
  786.   out_msg_buf->read_req_msg.address = 128;
  787.   msg_send_serial( out_msg_buf);
  788.   expect_msg(READ_ACK,in_msg_buf,1);
  789.   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
  790.  
  791.   for (regno=128; regno<=135; regno++) {
  792.       supply_register (SR_REGNUM(regno), data_p++);
  793.   }
  794.  
  795.   /* There doesn't seem to be any way to get these.  */
  796.   {
  797.     int val = -1;
  798.     supply_register (FPE_REGNUM, &val);
  799.     supply_register (INT_REGNUM, &val);
  800.     supply_register (FPS_REGNUM, &val);
  801.     supply_register (EXO_REGNUM, &val);
  802.   }
  803.  
  804.   DEXIT("mm_fetch_registerS()");
  805. }
  806.  
  807.  
  808. /****************************************************** REMOTE_STORE_REGISTERS
  809.  * Store register regno into the target.  
  810.  * If regno==-1 then store all the registers.
  811.  * Result is 0 for success, -1 for failure.
  812.  */
  813.  
  814. static int 
  815. mm_store_registers (regno)
  816. int regno;
  817. {
  818.   int result;
  819.   
  820.   if (regno >= 0)
  821.     return(store_register(regno));
  822.  
  823.   DENTER("mm_store_registers()");
  824.   result = 0;
  825.  
  826.   out_msg_buf->write_r_msg.code= WRITE_REQ;
  827.  
  828. /* Gr1/rsp */
  829.   out_msg_buf->write_r_msg.byte_count = 4*1;
  830.   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
  831.   out_msg_buf->write_r_msg.memory_space = GLOBAL_REG;
  832.   out_msg_buf->write_r_msg.address = 1;
  833.   out_msg_buf->write_r_msg.data[0] = read_register (GR1_REGNUM);
  834.  
  835.   msg_send_serial( out_msg_buf);
  836.   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
  837.     result = -1;
  838.   }
  839.  
  840. #if defined(GR64_REGNUM)
  841. /* Global registers gr64-gr95 */
  842.   out_msg_buf->write_r_msg.byte_count = 4* (32);
  843.   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
  844.   out_msg_buf->write_r_msg.address = 64;
  845.  
  846.   for (regno=GR64_REGNUM ; regno<GR64_REGNUM+32 ; regno++)
  847.     {
  848.       out_msg_buf->write_r_msg.data[regno-GR64_REGNUM] = read_register (regno);
  849.     }
  850.   msg_send_serial(out_msg_buf);
  851.   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
  852.     result = -1;
  853.   }
  854. #endif    /* GR64_REGNUM */
  855.  
  856. /* Global registers gr96-gr127 */
  857.   out_msg_buf->write_r_msg.byte_count = 4* (32);
  858.   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
  859.   out_msg_buf->write_r_msg.address = 96;
  860.   for (regno=GR96_REGNUM ; regno<GR96_REGNUM+32 ; regno++)
  861.     {
  862.       out_msg_buf->write_r_msg.data[regno-GR96_REGNUM] = read_register (regno);
  863.     }
  864.   msg_send_serial( out_msg_buf);
  865.   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
  866.     result = -1;
  867.   }
  868.  
  869. /* Local Registers */
  870.   out_msg_buf->write_r_msg.memory_space = LOCAL_REG;
  871.   out_msg_buf->write_r_msg.byte_count = 4*128;
  872.   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
  873.   out_msg_buf->write_r_msg.address = 0;
  874.  
  875.   for (regno = LR0_REGNUM ; regno < LR0_REGNUM+128 ; regno++)
  876.     {
  877.       out_msg_buf->write_r_msg.data[regno-LR0_REGNUM] = read_register (regno);
  878.     }
  879.   msg_send_serial( out_msg_buf);
  880.   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
  881.     result = -1;
  882.   }
  883.  
  884. /* Protected Special Registers */ 
  885.   /* VAB through TMR */
  886.   out_msg_buf->write_r_msg.memory_space = SPECIAL_REG;
  887.   out_msg_buf->write_r_msg.byte_count = 4* 10;
  888.   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
  889.   out_msg_buf->write_r_msg.address = 0;
  890.   for (regno = 0 ; regno<=9 ; regno++)    /* VAB through TMR */
  891.     out_msg_buf->write_r_msg.data[regno] = read_register (SR_REGNUM(regno));
  892.   msg_send_serial( out_msg_buf);
  893.   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
  894.     result = -1;
  895.   }
  896.  
  897.   /* PC0, PC1, PC2 possibly as shadow registers */
  898.   out_msg_buf->write_r_msg.byte_count = 4* 3;
  899.   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
  900.   for (regno=10 ; regno<=12 ; regno++)    /* LRU and MMU */
  901.     out_msg_buf->write_r_msg.data[regno-10] = read_register (SR_REGNUM(regno));
  902.   if (USE_SHADOW_PC) 
  903.     out_msg_buf->write_r_msg.address = 20;    /* SPC0 */
  904.   else 
  905.     out_msg_buf->write_r_msg.address = 10;    /* PC0 */
  906.   msg_send_serial( out_msg_buf);
  907.   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
  908.     result = -1;
  909.   }
  910.  
  911.   /* LRU and MMU */
  912.   out_msg_buf->write_r_msg.byte_count = 4* 2;
  913.   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
  914.   out_msg_buf->write_r_msg.address = 13;
  915.   for (regno=13 ; regno<=14 ; regno++)    /* LRU and MMU */
  916.     out_msg_buf->write_r_msg.data[regno-13] = read_register (SR_REGNUM(regno));
  917.   msg_send_serial( out_msg_buf);
  918.   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
  919.     result = -1;
  920.   }
  921.  
  922. /* Unprotected Special Registers */ 
  923.   out_msg_buf->write_r_msg.byte_count = 4*8;
  924.   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
  925.   out_msg_buf->write_r_msg.address = 128;
  926.   for (regno = 128 ; regno<=135 ; regno++)
  927.     out_msg_buf->write_r_msg.data[regno-128] = read_register(SR_REGNUM(regno));
  928.   msg_send_serial( out_msg_buf);
  929.   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
  930.     result = -1;
  931.   }
  932.  
  933.   registers_changed ();
  934.   DEXIT("mm_store_registers()");
  935.   return result;
  936. }
  937.  
  938. /*************************************************** REMOTE_PREPARE_TO_STORE */
  939. /* Get ready to modify the registers array.  On machines which store
  940.    individual registers, this doesn't need to do anything.  On machines
  941.    which store all the registers in one fell swoop, this makes sure
  942.    that registers contains all the registers from the program being
  943.    debugged.  */
  944.  
  945. static void
  946. mm_prepare_to_store ()
  947. {
  948.   /* Do nothing, since we can store individual regs */
  949. }
  950.  
  951. /******************************************************* REMOTE_XFER_MEMORY */
  952. static CORE_ADDR
  953. translate_addr(addr)
  954. CORE_ADDR addr;
  955. {
  956. #if defined(KERNEL_DEBUGGING)
  957.         /* Check for a virtual address in the kernel */
  958.         /* Assume physical address of ublock is in  paddr_u register */
  959.     /* FIXME: doesn't work for user virtual addresses */
  960.         if (addr >= UVADDR) {
  961.                 /* PADDR_U register holds the physical address of the ublock */
  962.                 CORE_ADDR i = (CORE_ADDR)read_register(PADDR_U_REGNUM);
  963.                 return(i + addr - (CORE_ADDR)UVADDR);
  964.         } else {
  965.             return(addr);
  966.         }
  967. #else
  968.         return(addr);
  969. #endif
  970. }
  971.  
  972. /******************************************************* REMOTE_FILES_INFO */
  973. static void
  974. mm_files_info ()
  975. {
  976.   printf ("\tAttached to %s at %d baud and running program %s.\n",
  977.           dev_name, baudrate, prog_name);
  978. }
  979.  
  980. /************************************************* REMOTE_INSERT_BREAKPOINT */
  981. static int
  982. mm_insert_breakpoint (addr, contents_cache)
  983.      CORE_ADDR addr;
  984.      char *contents_cache;
  985. {
  986.   DENTER("mm_insert_breakpoint()");
  987.   out_msg_buf->bkpt_set_msg.code = BKPT_SET;
  988.   out_msg_buf->bkpt_set_msg.length = 4*4;
  989.   out_msg_buf->bkpt_set_msg.memory_space = I_MEM;
  990.   out_msg_buf->bkpt_set_msg.bkpt_addr = (ADDR32) addr;
  991.   out_msg_buf->bkpt_set_msg.pass_count = 1;
  992.   out_msg_buf->bkpt_set_msg.bkpt_type = -1;    /* use illop for 29000 */
  993.   msg_send_serial( out_msg_buf);
  994.   if (expect_msg(BKPT_SET_ACK,in_msg_buf,1)) {
  995.       DEXIT("mm_insert_breakpoint() success");
  996.     return 0;        /* Success */
  997.   } else {
  998.       DEXIT("mm_insert_breakpoint() failure");
  999.     return 1;        /* Failure */
  1000.   }
  1001. }
  1002.  
  1003. /************************************************* REMOTE_DELETE_BREAKPOINT */
  1004. static int
  1005. mm_remove_breakpoint (addr, contents_cache)
  1006.      CORE_ADDR addr;
  1007.      char *contents_cache;
  1008. {
  1009.   DENTER("mm_remove_breakpoint()");
  1010.   out_msg_buf->bkpt_rm_msg.code = BKPT_RM;
  1011.   out_msg_buf->bkpt_rm_msg.length = 4*3;
  1012.   out_msg_buf->bkpt_rm_msg.memory_space = I_MEM;
  1013.   out_msg_buf->bkpt_rm_msg.bkpt_addr = (ADDR32) addr;
  1014.   msg_send_serial( out_msg_buf);
  1015.   if (expect_msg(BKPT_RM_ACK,in_msg_buf,1)) {
  1016.       DEXIT("mm_remove_breakpoint()");
  1017.     return 0;        /* Success */
  1018.   } else {
  1019.       DEXIT("mm_remove_breakpoint()");
  1020.     return 1;        /* Failure */
  1021.   }
  1022. }
  1023.  
  1024.  
  1025. /******************************************************* REMOTE_KILL */
  1026. static void
  1027. mm_kill(arg,from_tty)
  1028. char    *arg;
  1029. int     from_tty;
  1030. {
  1031.     char    buf[4];
  1032.  
  1033.       DENTER("mm_kill()");
  1034. #if defined(KERNEL_DEBUGGING)
  1035.     /* We don't ever kill the kernel */
  1036.     if (from_tty) {
  1037.         printf("Kernel not killed, but left in current state.\n");
  1038.          printf("Use detach to leave kernel running.\n");
  1039.     }
  1040. #else
  1041.       out_msg_buf->break_msg.code = BREAK;
  1042.       out_msg_buf->bkpt_set_msg.length = 4*0;
  1043.     expect_msg(HALT,in_msg_buf,from_tty);
  1044.     if (from_tty) {
  1045.         printf("Target has been stopped.");
  1046.         printf("Would you like to do a hardware reset (y/n) [n] ");
  1047.         fgets(buf,3,stdin);    
  1048.         if (buf[0] == 'y') {
  1049.             out_msg_buf->reset_msg.code = RESET;
  1050.             out_msg_buf->bkpt_set_msg.length = 4*0;
  1051.             expect_msg(RESET_ACK,in_msg_buf,from_tty);
  1052.             printf("Target has been reset.");
  1053.         }
  1054.     }
  1055.     pop_target();
  1056. #endif 
  1057.     DEXIT("mm_kill()");
  1058. }
  1059.  
  1060.  
  1061.  
  1062. /***************************************************************************/
  1063. /* 
  1064.  * Load a program into the target.
  1065.  */
  1066. static void
  1067. mm_load(arg_string,from_tty)
  1068. char    *arg_string;
  1069. int    from_tty;
  1070. {
  1071.   dont_repeat ();
  1072.  
  1073. #if defined(KERNEL_DEBUGGING)
  1074.   printf("The kernel had better be loaded already!  Loading not done.\n");
  1075. #else
  1076.   if (arg_string == 0)
  1077.     error ("The load command takes a file name");
  1078.  
  1079.   arg_string = tilde_expand (arg_string);
  1080.   make_cleanup (free, arg_string);
  1081.   QUIT;
  1082.   immediate_quit++;
  1083.   error("File loading is not yet supported for MiniMon.");
  1084.   /* FIXME, code to load your file here... */
  1085.   /* You may need to do an init_target_mm() */
  1086.   /* init_target_mm(?,?,?,?,?,?,?,?); */
  1087.   immediate_quit--;
  1088.   /* symbol_file_add (arg_string, from_tty, text_addr, 0); */
  1089. #endif
  1090.  
  1091. }
  1092.  
  1093. /************************************************ REMOTE_WRITE_INFERIOR_MEMORY
  1094. ** Copy LEN bytes of data from debugger memory at MYADDR
  1095.    to inferior's memory at MEMADDR.  Returns number of bytes written.  */
  1096. static int
  1097. mm_write_inferior_memory (memaddr, myaddr, len)
  1098.      CORE_ADDR memaddr;
  1099.      char *myaddr;
  1100.      int len;
  1101. {
  1102.   int i,nwritten;
  1103.  
  1104.   /* DENTER("mm_write_inferior_memory()"); */
  1105.   out_msg_buf->write_req_msg.code= WRITE_REQ;
  1106.   out_msg_buf->write_req_msg.memory_space = mm_memory_space(memaddr);    
  1107.  
  1108.   nwritten=0;
  1109.   while (nwritten < len) {
  1110.     int num_to_write = len - nwritten;
  1111.     if (num_to_write > MAXDATA) num_to_write = MAXDATA;
  1112.       for (i=0 ; i < num_to_write ; i++)
  1113.               out_msg_buf->write_req_msg.data[i] = myaddr[i+nwritten];
  1114.       out_msg_buf->write_req_msg.byte_count = num_to_write;
  1115.       out_msg_buf->write_req_msg.length = 3*4 + num_to_write; 
  1116.       out_msg_buf->write_req_msg.address = memaddr + nwritten;
  1117.       msg_send_serial(out_msg_buf);
  1118.  
  1119.       if (expect_msg(WRITE_ACK,in_msg_buf,1)) {
  1120.           nwritten += in_msg_buf->write_ack_msg.byte_count;
  1121.       } else {
  1122.         break;    
  1123.       }
  1124.   }
  1125.   /* DEXIT("mm_write_inferior_memory()"); */
  1126.   return(nwritten);
  1127. }
  1128.  
  1129. /************************************************* REMOTE_READ_INFERIOR_MEMORY
  1130. ** Read LEN bytes from inferior memory at MEMADDR.  Put the result
  1131.    at debugger address MYADDR.  Returns number of bytes read.  */
  1132. static int
  1133. mm_read_inferior_memory(memaddr, myaddr, len)
  1134.      CORE_ADDR memaddr;
  1135.      char *myaddr;
  1136.      int len;
  1137. {
  1138.   int i,nread;
  1139.  
  1140.   /* DENTER("mm_read_inferior_memory()"); */
  1141.   out_msg_buf->read_req_msg.code= READ_REQ;
  1142.   out_msg_buf->read_req_msg.memory_space = mm_memory_space(memaddr);
  1143.  
  1144.   nread=0;
  1145.   while (nread < len) {
  1146.     int num_to_read = (len - nread);
  1147.     if (num_to_read > MAXDATA) num_to_read = MAXDATA;
  1148.       out_msg_buf->read_req_msg.byte_count = num_to_read; 
  1149.       out_msg_buf->read_req_msg.length = 3*4 + num_to_read; 
  1150.       out_msg_buf->read_req_msg.address = memaddr + nread;
  1151.       msg_send_serial(out_msg_buf);
  1152.  
  1153.       if (expect_msg(READ_ACK,in_msg_buf,1)) {
  1154.           for (i=0 ; i<in_msg_buf->read_ack_msg.byte_count ; i++)
  1155.                   myaddr[i+nread] = in_msg_buf->read_ack_msg.data[i];
  1156.           nread += in_msg_buf->read_ack_msg.byte_count;
  1157.       } else {
  1158.         break;    
  1159.       }
  1160.   }
  1161.   return(nread);
  1162. }
  1163.  
  1164. /* FIXME!  Merge these two.  */
  1165. static int
  1166. mm_xfer_inferior_memory (memaddr, myaddr, len, write)
  1167.      CORE_ADDR memaddr;
  1168.      char *myaddr;
  1169.      int len;
  1170.      int write;
  1171. {
  1172.  
  1173.   memaddr = translate_addr(memaddr);
  1174.  
  1175.   if (write)
  1176.     return mm_write_inferior_memory (memaddr, myaddr, len);
  1177.   else
  1178.     return mm_read_inferior_memory (memaddr, myaddr, len);
  1179. }
  1180.  
  1181.  
  1182. /********************************************************** MSG_SEND_SERIAL
  1183. ** This function is used to send a message over the
  1184. ** serial line.
  1185. **
  1186. ** If the message is successfully sent, a zero is
  1187. ** returned.  If the message was not sendable, a -1
  1188. ** is returned.  This function blocks.  That is, it
  1189. ** does not return until the message is completely
  1190. ** sent, or until an error is encountered.
  1191. **
  1192. */
  1193.  
  1194. int
  1195. msg_send_serial(msg_ptr)
  1196.    union  msg_t  *msg_ptr;
  1197. {
  1198.    INT32  message_size;
  1199.    int    byte_count;
  1200.    int    result;
  1201.    char   c;
  1202.  
  1203.    /* Send message header */
  1204.    byte_count = 0;
  1205.    message_size = msg_ptr->generic_msg.length + (2 * sizeof(INT32));
  1206.    do {
  1207.       c = *((char *)msg_ptr+byte_count);
  1208.       result = write(mm_desc, &c, 1);
  1209.       if (result == 1) {
  1210.          byte_count = byte_count + 1;
  1211.       }
  1212.    } while ((byte_count < message_size) );
  1213.  
  1214.    return(0);
  1215. }  /* end msg_send_serial() */
  1216.  
  1217. /********************************************************** MSG_RECV_SERIAL
  1218. ** This function is used to receive a message over a
  1219. ** serial line.
  1220. **
  1221. ** If the message is waiting in the buffer, a zero is
  1222. ** returned and the buffer pointed to by msg_ptr is filled
  1223. ** in.  If no message was available, a -1 is returned.
  1224. ** If timeout==0, wait indefinetly for a character.
  1225. **
  1226. */
  1227.  
  1228. int
  1229. msg_recv_serial(msg_ptr)
  1230. union  msg_t  *msg_ptr;
  1231. {
  1232.    static INT32  length=0;
  1233.    static INT32  byte_count=0;
  1234.    int    result;
  1235.    char   c;
  1236.   if(msg_ptr == 0)        /* re-sync request */
  1237.   {  length=0;
  1238.      byte_count=0;
  1239. #ifdef HAVE_TERMIO
  1240.      /* The timeout here is the prevailing timeout set with VTIME */
  1241.      ->"timeout==0 semantics not supported"
  1242.      read(mm_desc, in_buf, BUFER_SIZE);
  1243. #else
  1244.      alarm (1);
  1245.      read(mm_desc, in_buf, BUFER_SIZE);
  1246.      alarm (0);
  1247. #endif
  1248.      return(0);
  1249.   }
  1250.    /* Receive message */
  1251. #ifdef HAVE_TERMIO
  1252. /* Timeout==0, help support the mm_wait() routine */
  1253.    ->"timeout==0 semantics not supported (and its nice if they are)"
  1254.    result = read(mm_desc, &c, 1);
  1255. #else
  1256.   alarm(timeout);
  1257.   result = read(mm_desc, &c, 1);
  1258.   alarm (0);
  1259. #endif
  1260.   if ( result < 0) {
  1261.       if (errno == EINTR) {
  1262.           error ("Timeout reading from remote system.");
  1263.       } else
  1264.     perror_with_name ("remote");
  1265.   } else if (result == 1) {
  1266.       *((char *)msg_ptr+byte_count) = c;
  1267.       byte_count = byte_count + 1;
  1268.   }
  1269.  
  1270.    /* Message header received.  Save message length. */
  1271.   if (byte_count == (2 * sizeof(INT32)))
  1272.       length = msg_ptr->generic_msg.length;
  1273.  
  1274.   if (byte_count >= (length + (2 * sizeof(INT32)))) {
  1275.       /* Message received */
  1276.       byte_count = 0;
  1277.       return(0);
  1278.   } else
  1279.       return (-1);
  1280.  
  1281. }  /* end msg_recv_serial() */
  1282.  
  1283. /********************************************************************* KBD_RAW
  1284. ** This function is used to put the keyboard in "raw"
  1285. ** mode for BSD Unix.  The original status is saved
  1286. ** so that it may be restored later.
  1287. */
  1288. TERMINAL kbd_tbuf;
  1289.  
  1290. int
  1291. kbd_raw() {
  1292.    int    result;
  1293.    TERMINAL tbuf;
  1294.  
  1295.    /* Get keyboard termio (to save to restore original modes) */
  1296. #ifdef HAVE_TERMIO
  1297.    result = ioctl(0, TCGETA, &kbd_tbuf);
  1298. #else
  1299.    result = ioctl(0, TIOCGETP, &kbd_tbuf);
  1300. #endif
  1301.    if (result == -1)
  1302.       return (errno);
  1303.  
  1304.    /* Get keyboard TERMINAL (for modification) */
  1305. #ifdef HAVE_TERMIO
  1306.    result = ioctl(0, TCGETA, &tbuf);
  1307. #else
  1308.    result = ioctl(0, TIOCGETP, &tbuf);
  1309. #endif
  1310.    if (result == -1)
  1311.       return (errno);
  1312.  
  1313.    /* Set up new parameters */
  1314. #ifdef HAVE_TERMIO
  1315.    tbuf.c_iflag = tbuf.c_iflag &
  1316.       ~(INLCR | ICRNL | IUCLC | ISTRIP | IXON | BRKINT);
  1317.    tbuf.c_lflag = tbuf.c_lflag & ~(ICANON | ISIG | ECHO);
  1318.    tbuf.c_cc[4] = 0;  /* MIN */
  1319.    tbuf.c_cc[5] = 0;  /* TIME */
  1320. #else
  1321.    /* FIXME: not sure if this is correct (matches HAVE_TERMIO). */
  1322.    tbuf.sg_flags |= RAW;
  1323.    tbuf.sg_flags |= ANYP;
  1324.    tbuf.sg_flags &= ~ECHO;
  1325. #endif
  1326.  
  1327.    /* Set keyboard termio to new mode (RAW) */
  1328. #ifdef HAVE_TERMIO
  1329.    result = ioctl(0, TCSETAF, &tbuf);
  1330. #else
  1331.    result = ioctl(0, TIOCSETP, &tbuf);
  1332. #endif 
  1333.    if (result == -1)
  1334.       return (errno);
  1335.  
  1336.    return (0);
  1337. }  /* end kbd_raw() */
  1338.  
  1339.  
  1340.  
  1341. /***************************************************************** KBD_RESTORE
  1342. ** This function is used to put the keyboard back in the
  1343. ** mode it was in before kbk_raw was called.  Note that
  1344. ** kbk_raw() must have been called at least once before
  1345. ** kbd_restore() is called.
  1346. */
  1347.  
  1348. int
  1349. kbd_restore() {
  1350.    int result;
  1351.  
  1352.    /* Set keyboard termio to original mode */
  1353. #ifdef HAVE_TERMIO
  1354.    result = ioctl(0, TCSETAF, &kbd_tbuf);
  1355. #else
  1356.    result = ioctl(0, TIOCGETP, &kbd_tbuf);
  1357. #endif
  1358.  
  1359.    if (result == -1)
  1360.       return (errno);
  1361.  
  1362.    return(0);
  1363. }  /* end kbd_cooked() */
  1364.  
  1365.  
  1366. /*****************************************************************************/ 
  1367. /* Fetch a single register indicatated by 'regno'. 
  1368.  * Returns 0/-1 on success/failure.  
  1369.  */
  1370. static int
  1371. fetch_register (regno)
  1372.      int regno;
  1373. {
  1374.      int  result;
  1375.   DENTER("mm_fetch_register()");
  1376.   out_msg_buf->read_req_msg.code= READ_REQ;
  1377.   out_msg_buf->read_req_msg.length = 4*3;
  1378.   out_msg_buf->read_req_msg.byte_count = 4;
  1379.  
  1380.   if (regno == GR1_REGNUM)
  1381.   { out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
  1382.     out_msg_buf->read_req_msg.address = 1;
  1383.   }
  1384.   else if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32)
  1385.   { out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
  1386.     out_msg_buf->read_req_msg.address = (regno - GR96_REGNUM) + 96;
  1387.   }
  1388. #if defined(GR64_REGNUM)
  1389.   else if (regno >= GR64_REGNUM && regno < GR64_REGNUM + 32 )
  1390.   { out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
  1391.     out_msg_buf->read_req_msg.address = (regno - GR64_REGNUM) + 64;
  1392.   }
  1393. #endif    /* GR64_REGNUM */
  1394.   else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128)
  1395.   { out_msg_buf->read_req_msg.memory_space = LOCAL_REG;
  1396.     out_msg_buf->read_req_msg.address = (regno - LR0_REGNUM);
  1397.   }
  1398.   else if (regno>=FPE_REGNUM && regno<=EXO_REGNUM)  
  1399.   { int val = -1;
  1400.     supply_register(160 + (regno - FPE_REGNUM),&val);
  1401.     return 0;        /* Pretend Success */
  1402.   }
  1403.   else 
  1404.   { out_msg_buf->read_req_msg.memory_space = SPECIAL_REG;
  1405.     out_msg_buf->read_req_msg.address = regnum_to_srnum(regno); 
  1406.   } 
  1407.  
  1408.   msg_send_serial(out_msg_buf);
  1409.  
  1410.   if (expect_msg(READ_ACK,in_msg_buf,1)) {
  1411.       supply_register (regno, &(in_msg_buf->read_r_ack_msg.data[0]));
  1412.     result = 0;
  1413.   } else {
  1414.     result = -1;
  1415.   }
  1416.   DEXIT("mm_fetch_register()");
  1417.   return result;
  1418. }
  1419. /*****************************************************************************/ 
  1420. /* Store a single register indicated by 'regno'. 
  1421.  * Returns 0/-1 on success/failure.  
  1422.  */
  1423. static int
  1424. store_register (regno)
  1425.      int regno;
  1426. {
  1427.      int  result;
  1428.  
  1429.   DENTER("store_register()");
  1430.   out_msg_buf->write_req_msg.code= WRITE_REQ;
  1431.   out_msg_buf->write_req_msg.length = 4*4;
  1432.   out_msg_buf->write_req_msg.byte_count = 4;
  1433.   out_msg_buf->write_r_msg.data[0] = read_register (regno);
  1434.  
  1435.   if (regno == GR1_REGNUM)
  1436.   { out_msg_buf->write_req_msg.memory_space = GLOBAL_REG;
  1437.     out_msg_buf->write_req_msg.address = 1;
  1438.     /* Setting GR1 changes the numbers of all the locals, so invalidate the 
  1439.      * register cache.  Do this *after* calling read_register, because we want 
  1440.      * read_register to return the value that write_register has just stuffed 
  1441.      * into the registers array, not the value of the register fetched from 
  1442.      * the inferior.  
  1443.      */
  1444.     registers_changed ();
  1445.   }
  1446. #if defined(GR64_REGNUM)
  1447.   else if (regno >= GR64_REGNUM && regno < GR64_REGNUM + 32 )
  1448.   { out_msg_buf->write_req_msg.memory_space = GLOBAL_REG;
  1449.     out_msg_buf->write_req_msg.address = (regno - GR64_REGNUM) + 64;
  1450.   }
  1451. #endif    /* GR64_REGNUM */
  1452.   else if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32)
  1453.   { out_msg_buf->write_req_msg.memory_space = GLOBAL_REG;
  1454.     out_msg_buf->write_req_msg.address = (regno - GR96_REGNUM) + 96;
  1455.   }
  1456.   else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128)
  1457.   { out_msg_buf->write_req_msg.memory_space = LOCAL_REG;
  1458.     out_msg_buf->write_req_msg.address = (regno - LR0_REGNUM);
  1459.   }
  1460.   else if (regno>=FPE_REGNUM && regno<=EXO_REGNUM)  
  1461.   { 
  1462.     return 0;        /* Pretend Success */
  1463.   }
  1464.   else     /* An unprotected or protected special register */
  1465.   { out_msg_buf->write_req_msg.memory_space = SPECIAL_REG;
  1466.     out_msg_buf->write_req_msg.address = regnum_to_srnum(regno); 
  1467.   } 
  1468.  
  1469.   msg_send_serial(out_msg_buf);
  1470.  
  1471.   if (expect_msg(WRITE_ACK,in_msg_buf,1)) {
  1472.     result = 0;
  1473.   } else {
  1474.     result = -1;
  1475.   }
  1476.   DEXIT("store_register()");
  1477.   return result;
  1478. }
  1479. /****************************************************************************/
  1480. /* 
  1481.  * Convert a gdb special register number to a 29000 special register number.
  1482.  */
  1483. static int
  1484. regnum_to_srnum(regno)
  1485. int    regno;
  1486. {
  1487.     switch(regno) {
  1488.         case VAB_REGNUM: return(0); 
  1489.         case OPS_REGNUM: return(1); 
  1490.         case CPS_REGNUM: return(2); 
  1491.         case CFG_REGNUM: return(3); 
  1492.         case CHA_REGNUM: return(4); 
  1493.         case CHD_REGNUM: return(5); 
  1494.         case CHC_REGNUM: return(6); 
  1495.         case RBP_REGNUM: return(7); 
  1496.         case TMC_REGNUM: return(8); 
  1497.         case TMR_REGNUM: return(9); 
  1498.         case NPC_REGNUM: return(USE_SHADOW_PC ? (20) : (10));
  1499.         case PC_REGNUM:  return(USE_SHADOW_PC ? (21) : (11));
  1500.         case PC2_REGNUM: return(USE_SHADOW_PC ? (22) : (12));
  1501.         case MMU_REGNUM: return(13); 
  1502.         case LRU_REGNUM: return(14); 
  1503.         case IPC_REGNUM: return(128); 
  1504.         case IPA_REGNUM: return(129); 
  1505.         case IPB_REGNUM: return(130); 
  1506.         case Q_REGNUM:   return(131); 
  1507.         case ALU_REGNUM: return(132); 
  1508.         case BP_REGNUM:  return(133); 
  1509.         case FC_REGNUM:  return(134); 
  1510.         case CR_REGNUM:  return(135); 
  1511.         case FPE_REGNUM: return(160); 
  1512.         case INT_REGNUM: return(161); 
  1513.         case FPS_REGNUM: return(162); 
  1514.         case EXO_REGNUM:return(164); 
  1515.         default:
  1516.             return(255);    /* Failure ? */
  1517.     }
  1518. }
  1519. /****************************************************************************/
  1520. /* 
  1521.  * Initialize the target debugger (minimon only).
  1522.  */
  1523. static void
  1524. init_target_mm(tstart,tend,dstart,dend,entry,ms_size,rs_size,arg_start)
  1525. ADDR32    tstart,tend,dstart,dend,entry;
  1526. INT32    ms_size,rs_size;
  1527. ADDR32    arg_start;
  1528. {
  1529.     out_msg_buf->init_msg.code = INIT;
  1530.     out_msg_buf->init_msg.length= sizeof(struct init_msg_t)-2*sizeof(INT32);
  1531.     out_msg_buf->init_msg.text_start = tstart;
  1532.     out_msg_buf->init_msg.text_end = tend;
  1533.     out_msg_buf->init_msg.data_start = dstart;
  1534.     out_msg_buf->init_msg.data_end = dend;
  1535.     out_msg_buf->init_msg.entry_point = entry;
  1536.     out_msg_buf->init_msg.mem_stack_size = ms_size;
  1537.     out_msg_buf->init_msg.reg_stack_size = rs_size;
  1538.     out_msg_buf->init_msg.arg_start = arg_start;
  1539.     msg_send_serial(out_msg_buf);
  1540.     expect_msg(INIT_ACK,in_msg_buf,1);
  1541. }
  1542. /****************************************************************************/
  1543. /* 
  1544.  * Return a pointer to a string representing the given message code.
  1545.  * Not all messages are represented here, only the ones that we expect
  1546.  * to be called with.
  1547.  */
  1548. static char*
  1549. msg_str(code)
  1550. INT32    code;
  1551. {
  1552.     static char cbuf[32];
  1553.  
  1554.     switch (code) {
  1555.     case BKPT_SET_ACK: sprintf(cbuf,"%s (%d)","BKPT_SET_ACK",code); break; 
  1556.     case BKPT_RM_ACK: sprintf(cbuf,"%s (%d)","BKPT_RM_ACK",code); break; 
  1557.     case INIT_ACK:       sprintf(cbuf,"%s (%d)","INIT_ACK",code); break; 
  1558.     case READ_ACK:       sprintf(cbuf,"%s (%d)","READ_ACK",code); break; 
  1559.     case WRITE_ACK:      sprintf(cbuf,"%s (%d)","WRITE_ACK",code); break; 
  1560.     case ERROR:       sprintf(cbuf,"%s (%d)","ERROR",code); break; 
  1561.     case HALT:     sprintf(cbuf,"%s (%d)","HALT",code); break; 
  1562.     default:    sprintf(cbuf,"UNKNOWN (%d)",code); break; 
  1563.     }
  1564.     return(cbuf);
  1565. }
  1566. /****************************************************************************/
  1567. /*
  1568.  * Selected (not all of them) error codes that we might get.
  1569.  */
  1570. static char* 
  1571. error_msg_str(code)
  1572. INT32    code;
  1573. {
  1574.     static char cbuf[50];
  1575.  
  1576.     switch (code) {
  1577.     case EMFAIL:     return("EMFAIL: unrecoverable error"); 
  1578.     case EMBADADDR: return("EMBADADDR: Illegal address"); 
  1579.     case EMBADREG:     return("EMBADREG: Illegal register "); 
  1580.     case EMACCESS:     return("EMACCESS: Could not access memory");
  1581.     case EMBADMSG:     return("EMBADMSG: Unknown message type"); 
  1582.     case EMMSG2BIG: return("EMMSG2BIG: Message to large"); 
  1583.     case EMNOSEND:     return("EMNOSEND: Could not send message"); 
  1584.     case EMNORECV:     return("EMNORECV: Could not recv message"); 
  1585.     case EMRESET:     return("EMRESET: Could not RESET target"); 
  1586.     case EMCONFIG:     return("EMCONFIG: Could not get target CONFIG"); 
  1587.     case EMSTATUS:     return("EMSTATUS: Could not get target STATUS"); 
  1588.     case EMREAD:     return("EMREAD: Could not READ target memory"); 
  1589.     case EMWRITE:     return("EMWRITE: Could not WRITE target memory"); 
  1590.     case EMBKPTSET: return("EMBKPTSET: Could not set breakpoint"); 
  1591.     case EMBKPTRM:    return("EMBKPTRM: Could not remove breakpoint"); 
  1592.     case EMBKPTSTAT:return("EMBKPTSTAT: Could not get breakpoint status"); 
  1593.     case EMBKPTNONE:return("EMBKPTNONE: All breakpoints in use"); 
  1594.     case EMBKPTUSED:return("EMBKPTUSED: Breakpoints already in use"); 
  1595.     case EMINIT:     return("EMINIT: Could not init target memory"); 
  1596.     case EMGO:     return("EMGO: Could not start execution"); 
  1597.     case EMSTEP:     return("EMSTEP: Could not single step"); 
  1598.     case EMBREAK:     return("EMBREAK: Could not BREAK"); 
  1599.     case EMCOMMERR: return("EMCOMMERR: Communication error"); 
  1600.     default:         sprintf(cbuf,"error number %d",code); break;
  1601.     } /* end switch */
  1602.  
  1603.     return (cbuf);
  1604. }
  1605. /****************************************************************************/
  1606. /* 
  1607.  *  Receive a message and expect it to be of type msgcode.
  1608.  *  Returns 0/1 on failure/success.
  1609.  */
  1610. static int
  1611. expect_msg(msgcode,msg_buf,from_tty)
  1612. INT32    msgcode;        /* Msg code we expect */
  1613. union msg_t *msg_buf;        /* Where to put  the message received */
  1614. int    from_tty;        /* Print message on error if non-zero */
  1615. {
  1616.   /* DENTER("expect_msg()"); */
  1617.   int    retries=0;
  1618.   while(msg_recv_serial(msg_buf) && (retries++<MAX_RETRIES)); 
  1619.   if (retries >= MAX_RETRIES) {
  1620.     printf("Expected msg %s, ",msg_str(msgcode));
  1621.     printf("no message received!\n");
  1622.         /* DEXIT("expect_msg() failure"); */
  1623.         return(0);        /* Failure */
  1624.   }
  1625.  
  1626.   if (msg_buf->generic_msg.code != msgcode) {
  1627.      if (from_tty) {
  1628.     printf("Expected msg %s, ",msg_str(msgcode));
  1629.     printf("got msg %s\n",msg_str(msg_buf->generic_msg.code));
  1630.         if (msg_buf->generic_msg.code == ERROR) 
  1631.         printf("%s\n",error_msg_str(msg_buf->error_msg.error_code));
  1632.      }
  1633.      /* DEXIT("expect_msg() failure"); */
  1634.      return(0);            /* Failure */
  1635.   }
  1636.   /* DEXIT("expect_msg() success"); */
  1637.   return(1);            /* Success */
  1638. }    
  1639. /****************************************************************************/
  1640. /*
  1641.  * Determine the MiniMon memory space qualifier based on the addr. 
  1642.  * FIXME: Can't distinguis I_ROM/D_ROM.  
  1643.  * FIXME: Doesn't know anything about I_CACHE/D_CACHE.
  1644.  */
  1645. static int
  1646. mm_memory_space(addr)
  1647. CORE_ADDR    *addr;
  1648. {
  1649.     ADDR32 tstart = target_config.I_mem_start;
  1650.     ADDR32 tend   = tstart + target_config.I_mem_size;  
  1651.     ADDR32 dstart = target_config.D_mem_start;
  1652.     ADDR32 dend   = tstart + target_config.D_mem_size;  
  1653.     ADDR32 rstart = target_config.ROM_start;
  1654.     ADDR32 rend   = tstart + target_config.ROM_size;  
  1655.  
  1656.     if (((ADDR32)addr >= tstart) && ((ADDR32)addr < tend)) { 
  1657.         return I_MEM;
  1658.     } else if (((ADDR32)addr >= dstart) && ((ADDR32)addr < dend)) { 
  1659.         return D_MEM;
  1660.     } else if (((ADDR32)addr >= rstart) && ((ADDR32)addr < rend)) {
  1661.         /* FIXME: how do we determine between D_ROM and I_ROM */
  1662.         return D_ROM;
  1663.     } else    /* FIXME: what do me do now? */
  1664.         return D_MEM;    /* Hmmm! */
  1665. }
  1666.  
  1667. /****************************************************************************/
  1668. /* 
  1669.  *  Define the target subroutine names 
  1670.  */
  1671. struct target_ops mm_ops = {
  1672.         "minimon", "Remote AMD/Minimon target",
  1673.     "Remote debug an AMD 290*0 using the MiniMon dbg core on the target",
  1674.         mm_open, mm_close,
  1675.         mm_attach, mm_detach, mm_resume, mm_wait,
  1676.         mm_fetch_registers, mm_store_registers,
  1677.         mm_prepare_to_store, 0, 0,   /* conv_to, conv_from */
  1678.         mm_xfer_inferior_memory,
  1679.         mm_files_info,
  1680.         mm_insert_breakpoint, mm_remove_breakpoint, /* Breakpoints */
  1681.         0, 0, 0, 0, 0,          /* Terminal handling */
  1682.         mm_kill,                 /* FIXME, kill */
  1683.         mm_load, 
  1684.         call_function_by_hand,
  1685.         0,                      /* lookup_symbol */
  1686.         mm_create_inferior,  /* create_inferior */
  1687.         mm_mourn,            /* mourn_inferior FIXME */
  1688.         process_stratum, 0, /* next */
  1689.         1, 1, 1, 1, 1,  /* all mem, mem, stack, regs, exec */
  1690.     0,0,        /* sections, sections_end */
  1691.         OPS_MAGIC,              /* Always the last thing */
  1692. };
  1693.  
  1694. void
  1695. _initialize_remote_mm()
  1696. {
  1697.   add_target (&mm_ops);
  1698. }
  1699.  
  1700. #ifdef NO_HIF_SUPPORT
  1701. service_HIF(msg)
  1702. union msg_t    *msg;
  1703. {
  1704.     return(0);    /* Emulate a failure */
  1705. }
  1706. #endif
  1707.